RPN calculators require numbers to be entered before the operation is performed. Operations have no priority - they are performed in the order entered. Consequently RPN calculators do not need parentheses.

Since numbers must be entered before the operation to be performed, to evaluate 1 + 2:

press the 1 button
press the Enter button
press the 2 button
press the + button


The result, 3, is left on the stack.

Note: Any pre-programmed function can be replaced with your own function or deleted.

To program an existing programmable button, right-click the programmable button. An integrated source code editor will be launched, allowing you to modify that button's function.

To program a new button, press the Edit Functions button and enter one or more functions. When you press the OK button the new functions will be automatically assigned to programmable buttons.

A programmable function's button is only enabled when the stack contains the correct number of arguments that the function expects, in the correct datatypes. In other words, if a function's button requires two double-precision floating-point numbers, there must be at least two items on the stack, and the top two must be of type double.

To supply a function with arguments, add items to the stack in the order that they appear in the function declaration. For example, consider the following function:

public static double SciNot(double n, double PowerOf10)

// Allow the user to enter numbers in scientific notation.
// Return n * 10 ^ PowerOf10.
    
{
  return n * Math.Pow(10.0, PowerOf10);
}

Enter the number first, then enter the power of 10. For example, enter 6.0221367 * 10²³ as follows:

6.0221367 Enter 23 Enter SciNot

The integrated source code editor has a multiple-line indent and unindent feature. To indent multiple lines, select the lines and press the Tab key. To unindent multiple lines, select the lines and press Shift+Tab.

If a function is taking too long, press Esc to cancel it. Note: you may need to single-click the icon in the taskbar before pressing Esc:

[assembly:Tab("Main",          1)]
[assembly:Tab("Math",          2)]
[assembly:Tab("Trig",          3)]
[assembly:Tab("Angles",        4)]
[assembly:Tab("Memory",        5)]
[assembly:Tab("Finance",       6)]
[assembly:Tab("Dates & Times", 7)]

In the Tab attribute, the first argument specifies the name of the tab. The second argument specifies the order in which it appears, from left to right.

// Display numerical values as floating point.
[Button("Main")]
public static void FloatingPoint()
{
  iapi.DisplayFormat = "";
}

The first argument to the Button attribute specifies the name of the tab to which the programmable button belongs. The second argument specifies the button text. This argument is optional and only needs to be specified if the button text differs from the method's name. For example:

[Button("Math", "n!")]
public static long Factorial(int n)

In this case the second argument is specified since the button text, "n!", is different than the method's name ("Factorial").

By default, when a custom function returns a null value, that null will be placed on the stack. To prevent this from happening, add the [DiscardNull] attribute above the function.

[Button("Computer Math", "Enter Binary")]
[DiscardNull()]
public static Integer EnterBinaryNumber()
...

Objects are displayed in the stack by calling their ToString() method. Your functions can return objects of any class, or values of any primitive type (int, bool, float, double, byte, etc).

If an item's value is wider than the stack, it will be truncated with an ellipsis (...) on its far right. To see the entire value, either double-click it, or selected it and select the View / Selected Stack Value menu item.

C# Programmable Calculator automatically saves the stack contents every time you close the program, and restores the stack when you run it later. One exception: If objects of user-defined classes are stored on the stack, the stack will not be restored when the program is run again.

int index;
Object o;
...
globals[index] = o;

By default, your custom functions can only the System namespace and a few others. To access other namespaces, first add the appropriate "using" statement, e.g.:

using System.Windows.Forms;

At this point, if the corresponding assembly has not been added, you'll get an error message like the following:

To add the assembly, press Configure Assemblies in the Error dialog box, or select Options / Settings in the main window:

When possible, values on the stack are converted to be compatible with function arguments. If the stack contains a floating-point value and the corresponding function argument is an integral type, the floating-point value is truncated and converted into that integral type.

C# code ignores numerical overflow by default. If you want your code to throw an exception when an overflow happens, use one of the following techniques:

Technique #1: Check for numeric overflow

Select Options / Settings. Select the Misc. tab and check the Check for numeric overflow checkbox. This setting affects all of your functions.

Technique #2: Checked Block

To enable overflow checking for specific functions, use checked blocks as follows:

public static long Factorial(int n)
    
// Calculates n! using a recursive algorithm.
    
{
  long result = 1;

  // By default, C# code will not throw
  // exceptions when overflows happen.  To
  // ensure that an exception is thrown when
  // overflows occur, enclose the code in a 
  // checked block.

  checked
  {
    if (n > 1)
    {
      result = n * Factorial(n - 1);
    }
  }
    
  return result;
}

Checked expressions can also be enclosed in parenthesis, for example:

public static void Overflow()
{
  short x = 32000;
  short y = 32000;
      
  short z = checked((short) (x + y));
}

Example

You can create and use user-defined classes like the following:

public class UserDefined
{
  public UserDefined(int intValue)
  {
    this.intValue = intValue;
  }

  public override String ToString()
  {
    return intValue.ToString();
  }

  public int intValue;
}

public UserDefined pushUserDefined()
{
  return new UserDefined(42);
}

public int popUserDefined(UserDefined userDefined)
{
  return userDefined.intValue;
}

Caveats

If you call a function that places a user-defined object on the stack, and then make changes to functions (by pressing the Edit Functions button, or by adding or deleting any assemblies), any user-defined objects on the stack cannot be passed to functions.

In this situation you'll get the following error message:

One or more of the stack values did not match the corresponding argument types expected by method.

To resolve this issue, simply press the Clear All button. This will remove the incompatible objects from the stack. When user-defined objects are subsequently pushed on the stack they can be passed to functions.

In other words, you can't store user-defined objects on the stack, and then make changes to their class(es), and then expect the old, out-of-date, objects to be compatible with methods that are expecting the new objects.

Finally, if there are user-defined objects on the stack when the program is closed, when it is run again the stack will be empty.

C# Programmable Calculator includes an assembly named CSPCUtil.dll that provides some useful utility functions that you can use in your programmable functions:

Method/Property	Description	Arguments	Return Value
Util.Prompt	Prompts the user for a value of the specified type.	1: String caption Caption displayed on the dialog box 2: String prompt Text displayed above the TextBox 3: String initialValue Initial text in the TextBox 4: Type valueType Data type of value	If the user presses OK, the text in the TextBox is converted to an object of the type specified by valueType and that object is returned. If the user presses Cancel, a null object is returned.
Util.TextLines.Display	Displays lines of text in a dialog box.	1: String caption Caption displayed on the dialog box	n/a (this is a void method)
Util.TextLines.AddLine (overloaded)	Displays lines of text in a dialog box.	1: string line The next line of text to be displayed.	n/a (this is a void method)
Util.TextLines.AddLine (overloaded)	Displays lines of text in a dialog box.	1: string line The next line of text to be displayed. 2: params object[] parameters Parameters to be inserted into the line of text. Parameters are inserted into the line of text by an internal call to string.Format. For example, the following call will add a line of text with the values of profit and expense expressed as currency amounts: TextLines textLines = new TextLines(); double profit = 12345678.90; textLines.AddLine("Profit: {0:C}", profit); textLines.Display("XML"); The above code displayes the following for the English (United States) Locale: Profit: $12,345,678.90	n/a (this is a void method)
Util.DisplayBrowser	Displays the specified HTML or URL in a web browser window in a dialog box.	1: String caption Caption displayed on the dialog box 2: String content Contains the HTML or the URL to display 3: bool html Specify a value of true if the content argument contains HTML. If the content argument contains a URL specify a value of false.	n/a (this is a void method)
Util.DisplayBrowser	Displays the specified HTML or URL in a web browser window in a dialog box, optionally maximized.	1: String caption Caption displayed on the dialog box 2: String content Contains the HTML or the URL to display 3: bool html Specify a value of true if the content argument contains HTML. If the content argument contains a URL specify a value of false. 4: bool fullScreen Specify whether or not the browser form should launch in maximized mode.	n/a (this is a void method)
Util.GetDate	Prompts the user to select a date from a calendar.	1: String caption Caption displayed on the dialog box 2: DateTime defaultDate Specifies the date that is initially selected.	Returns a DateTime object if the user selects a date. If the user cancels the dialog box a null value will be returned.
Util.GetDateRange	Prompts the user to select a range of dates from a calendar.	1: DateTime defaultDate Date that will be selected by default.	If the user selects a date range, a SelectionRange object will be returned. To extract the start and end date from the SelectionRange object, access the Begin and End properties, respectively. If the user cancels the dialog box, a null value will be returned.
Util.GetWebPageText	Retrieves the HTML text in the web page specified by the url.	1: string url URL of the web page. 2: int timeoutInSeconds timeoutInSeconds specifies how long to wait for the page contents to be downloaded.	a string containing the web page text, or null if the page could not be retrieved.
GraphicsForm Constructor	Constructs a GraphicsForm object which allows you to display graphics in a modal dialog box.	1: String caption Caption displayed on the dialog box 2: Size graphicsSize Width and height of graphics	n/a (this is a constructor)
GraphicsForm.ShowDialog	Launches the modal graphics dialog box. Call this method after you've finished drawing graphics.	n/a (this is a void method)
GraphicsForm.GraphicsObject Property	The GraphicsObject readonly property returns a Graphics object that can be used to draw graphics on the Form. Be sure to finish drawing all graphics before calling ShowDialog.	n/a	a Graphics object

Examples

Prompt

PromptForPrice launches a dialog box with an initial value of 1.00 displayed. When the user presses the OK button a double value is returned containing the specified value. If the user presses Cancel, null is returned.

public double PromptForPrice()
{
  return (double) Util.Prompt("Enter Price", "Price:", "1.00", typeof(double));
}

TextLines

FibonacciReport generates a textual report displaying the Fibonacci numbers from 1 to max. It uses an ArrayList to store the lines that will be used in the report because ArrayLists can dynamically grow. It's easy to convert an ArrayList in to a String array, just use the ArrayList.ToArray method.

[Button("Test")]
public void FibonacciReport(int max)
{
  TextLines textLines = new TextLines();

  for (int i = 1; i <= max; i++)
  {
    textLines.AddLine("Fib({0}) = {1}", i, Fib(i));
  }

  textLines.Display("Fibonacci Numbers");
}

DisplayBrowser

BrowserDemo first launches the dialog box displaying the www.PersonalMicroCosms.com website. After the user presses the Close button, the dialog box is launched again, displaying the specified HTML.

public static void BrowserDemo()
{
  // Display the www.PersonalMicroCosms.com website:
  Util.DisplayBrowser("Personal MicroCosms", "www.PersonalMicroCosms.com", false);

  // Display HTML text:
  String htmlText = "<HTML><BODY><P>THIS IS A PARAGRAPH</P></BODY></HTML>";

  Util.DisplayBrowser("HTML", htmlText, true);
}

GraphicsForm

graphicsDemo creates a GraphicsForm, launches it, and then draws random lines with random colors.

public void graphicsDemo()
{
  const int width  = 2000;
  const int height = 2000;

  using (GraphicsForm gf = new GraphicsForm("interesting graphic", new Size(width, height)))
  {
    Graphics g = gf.GraphicsObject;
  
    Random r = new Random();
  
    for (int i = 0; i < 1000; i++)
    {
      int x1 = r.Next(width);
      int x2 = r.Next(width);
  
      int y1 = r.Next(height);
      int y2 = r.Next(height);
  
      g.DrawLine(new Pen(Color.FromArgb(r.Next(256), r.Next(256), r.Next(256))), x1, y1, x2, y2);
    }
  
    gf.ShowDialog();
  }
}

C# Programmable Calculator has an API that can be called from your programmable functions. To access this API, use the iapi member and call the following methods:

Use the istack member variable to manipulate the stack in custom functions. the istack object implements the IStack interface:

Method/Property	Description	Arguments	Return Value
StackSize Property	Returns the number of items on the stack	n/a	Number of items on the stack (int)
PopItem	Returns the item on the top of the stack	n/a	Item on the top of the stack (object)
PushItem	Inserts the specified item on the top of the stack	Item to push (object)	n/a (this is a void method)
ReadItem	Returns the item on the top of the stack without removing it from the stack	n/a	Item on the top of the stack (object)

For example, the expression istack.StackSize will be equal to the number of items on the stack.

If you create classes that implement this interface, objects of that class on the stack will be automatically converted to doubles when necessary. For example, if an object that implements IConvertToDouble is on the stack when the user presses the Recip button, the object will be converted to a double. Then the reciprocal will be calculated and the result will be placed on the stack.

The IConvertToDouble interface is in the CSPCUtil assembly.

Method/Property	Description	Arguments	Return Value
ToDouble	converts the object to a double	n/a	Value of the object (double)

Assert

In your functions you can use Debug.Assert to ensure that specified conditions are true. If they are ever not true, a message box will be displayed, which will help you find the error in your code.

For example, since dividing by zero is an error, the following function uses Assert to verify that the denominator is never zero. If it ever is, an error message will be displayed that pinpoints the precise location of the problem in your code.

public double divide(double numerator, double denominator)
{
  // denominator must not be zero!

  Debug.Assert(denominator != 0.0);

  return numerator / denominator;
}

To enable Asserts in your code, make sure you've included the following using statement:

using System.Diagnostics;

Then select Options / Settings and select the Misc. tab and make sure the Allow debugging features checkbox is checked.

Trace

You can add code to your functions that will output trace messages for debugging purposes. For example:

public void TRACEDemo(double d)
{
  Trace.WriteLine("User entered a value of " + d.ToString());
}

The trace messages will appear in a separate window.

To enable Asserts in your code, make sure you've included the following using statement:

using System.Diagnostics;

Then select Options / Settings and select the Misc. tab and make sure the Allow tracing features checkbox is checked. Then select View / Trace Window, which will launch the dialog box in which the trace messages will appear.